home *** CD-ROM | disk | FTP | other *** search
/ Aminet 30 / Aminet 30 (1999)(Schatztruhe)[!][Apr 1999].iso / Aminet / dev / lang / SmallEiffel.lha / SmallEiffel / bin_c / compile_to_jvm46.c < prev    next >
C/C++ Source or Header  |  1998-12-22  |  8KB  |  604 lines
  1. /*
  2. -- ANSI C code generated by :
  3. -- SmallEiffel The GNU Eiffel Compiler -- Release (- 0.79)      --
  4. -- Copyright (C), 1994-98 - LORIA - UHP - CRIN - INRIA - FRANCE --
  5. -- Dominique COLNET and Suzanne COLLIN -    colnet@loria.fr     --
  6. --                 http://www.loria.fr/SmallEiffel              --
  7. */
  8. #include "compile_to_jvm.h"
  9.  
  10.  
  11. void*se_ma195(int argc,...){
  12. T195*m;
  13. va_list pa;
  14. T0**s;
  15. m=malloc(sizeof(*m));
  16. *m=M195;
  17. if(argc){
  18. s=malloc(argc*sizeof(*s));
  19. m->_storage=s;
  20. m->_capacity=argc;
  21. m->_lower=1;
  22. m->_upper=argc;
  23. va_start(pa,argc);
  24. while(argc--){
  25. *(s++)=((void*)(va_arg(pa,char*)));
  26. }
  27. va_end(pa);
  28. }
  29. else{
  30. m->_storage=NULL;
  31. m->_capacity=0;
  32. m->_lower=1;
  33. m->_upper=0;
  34. }
  35. return m;}
  36.  
  37.  
  38. void*se_ma99(int argc,...){
  39. T99*m;
  40. va_list pa;
  41. T0**s;
  42. m=malloc(sizeof(*m));
  43. *m=M99;
  44. if(argc){
  45. s=malloc(argc*sizeof(*s));
  46. m->_storage=s;
  47. m->_capacity=argc;
  48. m->_lower=1;
  49. m->_upper=argc;
  50. va_start(pa,argc);
  51. while(argc--){
  52. *(s++)=((void*)(va_arg(pa,char*)));
  53. }
  54. va_end(pa);
  55. }
  56. else{
  57. m->_storage=NULL;
  58. m->_capacity=0;
  59. m->_lower=1;
  60. m->_upper=0;
  61. }
  62. return m;}
  63.  
  64.  
  65. void*se_ma108(int argc,...){
  66. T108*m;
  67. va_list pa;
  68. T0**s;
  69. m=malloc(sizeof(*m));
  70. *m=M108;
  71. if(argc){
  72. s=malloc(argc*sizeof(*s));
  73. m->_storage=s;
  74. m->_capacity=argc;
  75. m->_lower=1;
  76. m->_upper=argc;
  77. va_start(pa,argc);
  78. while(argc--){
  79. *(s++)=((void*)(va_arg(pa,char*)));
  80. }
  81. va_end(pa);
  82. }
  83. else{
  84. m->_storage=NULL;
  85. m->_capacity=0;
  86. m->_lower=1;
  87. m->_upper=0;
  88. }
  89. return m;}
  90.  
  91.  
  92. void*se_ma114(int argc,...){
  93. T114*m;
  94. va_list pa;
  95. T0**s;
  96. m=malloc(sizeof(*m));
  97. *m=M114;
  98. if(argc){
  99. s=malloc(argc*sizeof(*s));
  100. m->_storage=s;
  101. m->_capacity=argc;
  102. m->_lower=1;
  103. m->_upper=argc;
  104. va_start(pa,argc);
  105. while(argc--){
  106. *(s++)=((void*)(va_arg(pa,char*)));
  107. }
  108. va_end(pa);
  109. }
  110. else{
  111. m->_storage=NULL;
  112. m->_capacity=0;
  113. m->_lower=1;
  114. m->_upper=0;
  115. }
  116. return m;}
  117.  
  118.  
  119. void*se_ma313(int argc,...){
  120. T313*m;
  121. va_list pa;
  122. T0**s;
  123. m=malloc(sizeof(*m));
  124. *m=M313;
  125. if(argc){
  126. s=malloc(argc*sizeof(*s));
  127. m->_storage=s;
  128. m->_capacity=argc;
  129. m->_lower=1;
  130. m->_upper=argc;
  131. va_start(pa,argc);
  132. while(argc--){
  133. *(s++)=((void*)(va_arg(pa,char*)));
  134. }
  135. va_end(pa);
  136. }
  137. else{
  138. m->_storage=NULL;
  139. m->_capacity=0;
  140. m->_lower=1;
  141. m->_upper=0;
  142. }
  143. return m;}
  144.  
  145.  
  146. void*se_ma225(int argc,...){
  147. T225*m;
  148. va_list pa;
  149. T0**s;
  150. m=malloc(sizeof(*m));
  151. *m=M225;
  152. if(argc){
  153. s=malloc(argc*sizeof(*s));
  154. m->_storage=s;
  155. m->_capacity=argc;
  156. m->_lower=1;
  157. m->_upper=argc;
  158. va_start(pa,argc);
  159. while(argc--){
  160. *(s++)=((void*)(va_arg(pa,char*)));
  161. }
  162. va_end(pa);
  163. }
  164. else{
  165. m->_storage=NULL;
  166. m->_capacity=0;
  167. m->_lower=1;
  168. m->_upper=0;
  169. }
  170. return m;}
  171.  
  172.  
  173. void*se_ma323(int argc,...){
  174. T323*m;
  175. va_list pa;
  176. T0**s;
  177. m=malloc(sizeof(*m));
  178. *m=M323;
  179. if(argc){
  180. s=malloc(argc*sizeof(*s));
  181. m->_storage=s;
  182. m->_capacity=argc;
  183. m->_lower=1;
  184. m->_upper=argc;
  185. va_start(pa,argc);
  186. while(argc--){
  187. *(s++)=((void*)(va_arg(pa,char*)));
  188. }
  189. va_end(pa);
  190. }
  191. else{
  192. m->_storage=NULL;
  193. m->_capacity=0;
  194. m->_lower=1;
  195. m->_upper=0;
  196. }
  197. return m;}
  198.  
  199.  
  200. void*se_ma327(int argc,...){
  201. T327*m;
  202. va_list pa;
  203. T0**s;
  204. m=malloc(sizeof(*m));
  205. *m=M327;
  206. if(argc){
  207. s=malloc(argc*sizeof(*s));
  208. m->_storage=s;
  209. m->_capacity=argc;
  210. m->_lower=1;
  211. m->_upper=argc;
  212. va_start(pa,argc);
  213. while(argc--){
  214. *(s++)=((void*)(va_arg(pa,char*)));
  215. }
  216. va_end(pa);
  217. }
  218. else{
  219. m->_storage=NULL;
  220. m->_capacity=0;
  221. m->_lower=1;
  222. m->_upper=0;
  223. }
  224. return m;}
  225.  
  226.  
  227. void*se_ma232(int argc,...){
  228. T232*m;
  229. va_list pa;
  230. T0**s;
  231. m=malloc(sizeof(*m));
  232. *m=M232;
  233. if(argc){
  234. s=malloc(argc*sizeof(*s));
  235. m->_storage=s;
  236. m->_capacity=argc;
  237. m->_lower=1;
  238. m->_upper=argc;
  239. va_start(pa,argc);
  240. while(argc--){
  241. *(s++)=((void*)(va_arg(pa,char*)));
  242. }
  243. va_end(pa);
  244. }
  245. else{
  246. m->_storage=NULL;
  247. m->_capacity=0;
  248. m->_lower=1;
  249. m->_upper=0;
  250. }
  251. return m;}
  252.  
  253.  
  254. void*se_ma239(int argc,...){
  255. T239*m;
  256. va_list pa;
  257. T0**s;
  258. m=malloc(sizeof(*m));
  259. *m=M239;
  260. if(argc){
  261. s=malloc(argc*sizeof(*s));
  262. m->_storage=s;
  263. m->_capacity=argc;
  264. m->_lower=1;
  265. m->_upper=argc;
  266. va_start(pa,argc);
  267. while(argc--){
  268. *(s++)=((void*)(va_arg(pa,char*)));
  269. }
  270. va_end(pa);
  271. }
  272. else{
  273. m->_storage=NULL;
  274. m->_capacity=0;
  275. m->_lower=1;
  276. m->_upper=0;
  277. }
  278. return m;}
  279.  
  280.  
  281. void*se_ma242(int argc,...){
  282. T242*m;
  283. va_list pa;
  284. T0**s;
  285. m=malloc(sizeof(*m));
  286. *m=M242;
  287. if(argc){
  288. s=malloc(argc*sizeof(*s));
  289. m->_storage=s;
  290. m->_capacity=argc;
  291. m->_lower=1;
  292. m->_upper=argc;
  293. va_start(pa,argc);
  294. while(argc--){
  295. *(s++)=((void*)(va_arg(pa,char*)));
  296. }
  297. va_end(pa);
  298. }
  299. else{
  300. m->_storage=NULL;
  301. m->_capacity=0;
  302. m->_lower=1;
  303. m->_upper=0;
  304. }
  305. return m;}
  306.  
  307.  
  308. void*se_ma340(int argc,...){
  309. T340*m;
  310. va_list pa;
  311. T0**s;
  312. m=malloc(sizeof(*m));
  313. *m=M340;
  314. if(argc){
  315. s=malloc(argc*sizeof(*s));
  316. m->_storage=s;
  317. m->_capacity=argc;
  318. m->_lower=1;
  319. m->_upper=argc;
  320. va_start(pa,argc);
  321. while(argc--){
  322. *(s++)=((void*)(va_arg(pa,char*)));
  323. }
  324. va_end(pa);
  325. }
  326. else{
  327. m->_storage=NULL;
  328. m->_capacity=0;
  329. m->_lower=1;
  330. m->_upper=0;
  331. }
  332. return m;}
  333.  
  334.  
  335. void*se_ma54(int argc,...){
  336. T54*m;
  337. va_list pa;
  338. T0**s;
  339. m=malloc(sizeof(*m));
  340. *m=M54;
  341. if(argc){
  342. s=malloc(argc*sizeof(*s));
  343. m->_storage=s;
  344. m->_capacity=argc;
  345. m->_lower=1;
  346. m->_upper=argc;
  347. va_start(pa,argc);
  348. while(argc--){
  349. *(s++)=((void*)(va_arg(pa,char*)));
  350. }
  351. va_end(pa);
  352. }
  353. else{
  354. m->_storage=NULL;
  355. m->_capacity=0;
  356. m->_lower=1;
  357. m->_upper=0;
  358. }
  359. return m;}
  360.  
  361.  
  362. void*se_ma265(int argc,...){
  363. T265*m;
  364. va_list pa;
  365. T0**s;
  366. m=malloc(sizeof(*m));
  367. *m=M265;
  368. if(argc){
  369. s=malloc(argc*sizeof(*s));
  370. m->_storage=s;
  371. m->_capacity=argc;
  372. m->_lower=1;
  373. m->_upper=argc;
  374. va_start(pa,argc);
  375. while(argc--){
  376. *(s++)=((void*)(va_arg(pa,char*)));
  377. }
  378. va_end(pa);
  379. }
  380. else{
  381. m->_storage=NULL;
  382. m->_capacity=0;
  383. m->_lower=1;
  384. m->_upper=0;
  385. }
  386. return m;}
  387.  
  388.  
  389. void*se_ma73(int argc,...){
  390. T73*m;
  391. va_list pa;
  392. T0**s;
  393. m=malloc(sizeof(*m));
  394. *m=M73;
  395. if(argc){
  396. s=malloc(argc*sizeof(*s));
  397. m->_storage=s;
  398. m->_capacity=argc;
  399. m->_lower=1;
  400. m->_upper=argc;
  401. va_start(pa,argc);
  402. while(argc--){
  403. *(s++)=((void*)(va_arg(pa,char*)));
  404. }
  405. va_end(pa);
  406. }
  407. else{
  408. m->_storage=NULL;
  409. m->_capacity=0;
  410. m->_lower=1;
  411. m->_upper=0;
  412. }
  413. return m;}
  414.  
  415.  
  416. void*se_ma365(int argc,...){
  417. T365*m;
  418. va_list pa;
  419. T0**s;
  420. m=malloc(sizeof(*m));
  421. *m=M365;
  422. if(argc){
  423. s=malloc(argc*sizeof(*s));
  424. m->_storage=s;
  425. m->_capacity=argc;
  426. m->_lower=1;
  427. m->_upper=argc;
  428. va_start(pa,argc);
  429. while(argc--){
  430. *(s++)=((void*)(va_arg(pa,char*)));
  431. }
  432. va_end(pa);
  433. }
  434. else{
  435. m->_storage=NULL;
  436. m->_capacity=0;
  437. m->_lower=1;
  438. m->_upper=0;
  439. }
  440. return m;}
  441.  
  442.  
  443. void*se_ma79(int argc,...){
  444. T79*m;
  445. va_list pa;
  446. T0**s;
  447. m=malloc(sizeof(*m));
  448. *m=M79;
  449. if(argc){
  450. s=malloc(argc*sizeof(*s));
  451. m->_storage=s;
  452. m->_capacity=argc;
  453. m->_lower=1;
  454. m->_upper=argc;
  455. va_start(pa,argc);
  456. while(argc--){
  457. *(s++)=((void*)(va_arg(pa,char*)));
  458. }
  459. va_end(pa);
  460. }
  461. else{
  462. m->_storage=NULL;
  463. m->_capacity=0;
  464. m->_lower=1;
  465. m->_upper=0;
  466. }
  467. return m;}
  468.  
  469.  
  470. void*se_ma175(int argc,...){
  471. T175*m;
  472. va_list pa;
  473. T2*s;
  474. m=malloc(sizeof(*m));
  475. *m=M175;
  476. if(argc){
  477. s=malloc(argc*sizeof(*s));
  478. m->_storage=s;
  479. m->_capacity=argc;
  480. m->_lower=1;
  481. m->_upper=argc;
  482. va_start(pa,argc);
  483. while(argc--){
  484. *(s++)=va_arg(pa,int);
  485. }
  486. va_end(pa);
  487. }
  488. else{
  489. m->_storage=NULL;
  490. m->_capacity=0;
  491. m->_lower=1;
  492. m->_upper=0;
  493. }
  494. return m;}
  495.  
  496.  
  497. void*se_ma83(int argc,...){
  498. T83*m;
  499. va_list pa;
  500. T0**s;
  501. m=malloc(sizeof(*m));
  502. *m=M83;
  503. if(argc){
  504. s=malloc(argc*sizeof(*s));
  505. m->_storage=s;
  506. m->_capacity=argc;
  507. m->_lower=1;
  508. m->_upper=argc;
  509. va_start(pa,argc);
  510. while(argc--){
  511. *(s++)=((void*)(va_arg(pa,char*)));
  512. }
  513. va_end(pa);
  514. }
  515. else{
  516. m->_storage=NULL;
  517. m->_capacity=0;
  518. m->_lower=1;
  519. m->_upper=0;
  520. }
  521. return m;}
  522.  
  523.  
  524. void*se_ma91(int argc,...){
  525. T91*m;
  526. va_list pa;
  527. T0**s;
  528. m=malloc(sizeof(*m));
  529. *m=M91;
  530. if(argc){
  531. s=malloc(argc*sizeof(*s));
  532. m->_storage=s;
  533. m->_capacity=argc;
  534. m->_lower=1;
  535. m->_upper=argc;
  536. va_start(pa,argc);
  537. while(argc--){
  538. *(s++)=((void*)(va_arg(pa,char*)));
  539. }
  540. va_end(pa);
  541. }
  542. else{
  543. m->_storage=NULL;
  544. m->_capacity=0;
  545. m->_lower=1;
  546. m->_upper=0;
  547. }
  548. return m;}
  549.  
  550.  
  551. void*se_ma284(int argc,...){
  552. T284*m;
  553. va_list pa;
  554. T0**s;
  555. m=malloc(sizeof(*m));
  556. *m=M284;
  557. if(argc){
  558. s=malloc(argc*sizeof(*s));
  559. m->_storage=s;
  560. m->_capacity=argc;
  561. m->_lower=1;
  562. m->_upper=argc;
  563. va_start(pa,argc);
  564. while(argc--){
  565. *(s++)=((void*)(va_arg(pa,char*)));
  566. }
  567. va_end(pa);
  568. }
  569. else{
  570. m->_storage=NULL;
  571. m->_capacity=0;
  572. m->_lower=1;
  573. m->_upper=0;
  574. }
  575. return m;}
  576.  
  577.  
  578. void*se_ma189(int argc,...){
  579. T189*m;
  580. va_list pa;
  581. T0**s;
  582. m=malloc(sizeof(*m));
  583. *m=M189;
  584. if(argc){
  585. s=malloc(argc*sizeof(*s));
  586. m->_storage=s;
  587. m->_capacity=argc;
  588. m->_lower=1;
  589. m->_upper=argc;
  590. va_start(pa,argc);
  591. while(argc--){
  592. *(s++)=((void*)(va_arg(pa,char*)));
  593. }
  594. va_end(pa);
  595. }
  596. else{
  597. m->_storage=NULL;
  598. m->_capacity=0;
  599. m->_lower=1;
  600. m->_upper=0;
  601. }
  602. return m;}
  603.  
  604.